home *** CD-ROM | disk | FTP | other *** search
/ Kompuutteri K-CD 2002 #1 / K-CD_2002-01.iso / Delphi / INSTALL / program files / Borland / Delphi6 / Source / Rtl / Win / TlHelp32.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  2001-05-22  |  15.6 KB  |  482 lines
  1. { *********************************************************************** }
  2. {                                                                         }
  3. { Delphi Runtime Library                                                  }
  4. {                                                                         }
  5. { Copyright (c) 1996-2001 Borland Software Corporation                    }
  6. {                                                                         }
  7. { *********************************************************************** }
  8.  
  9. {*******************************************************}
  10. {       Tool Help Functions, Types, and Definitions     }
  11. {*******************************************************}
  12.  
  13. unit TlHelp32;
  14.  
  15. {$WEAKPACKAGEUNIT}
  16.  
  17. interface
  18.  
  19. uses Windows;
  20.  
  21. {$HPPEMIT '#include <tlhelp32.h>'}
  22.  
  23. const
  24. {$EXTERNALSYM MAX_MODULE_NAME32}
  25.   MAX_MODULE_NAME32 = 255;
  26.  
  27. (****** Shapshot function **********************************************)
  28.  
  29. {$EXTERNALSYM CreateToolhelp32Snapshot}
  30. function CreateToolhelp32Snapshot(dwFlags, th32ProcessID: DWORD): THandle;
  31.  
  32. type
  33.   TCreateToolhelp32Snapshot = function (dwFlags, th32ProcessID: DWORD): THandle stdcall;
  34. //
  35. // The th32ProcessID argument is only used if TH32CS_SNAPHEAPLIST or
  36. // TH32CS_SNAPMODULE is specified. th32ProcessID == 0 means the current
  37. // process.
  38. //
  39. // NOTE that all of the snapshots are global except for the heap and module
  40. //  lists which are process specific. To enumerate the heap or module
  41. //  state for all WIN32 processes call with TH32CS_SNAPALL and the
  42. //  current process. Then for each process in the TH32CS_SNAPPROCESS
  43. //  list that isn't the current process, do a call with just
  44. //  TH32CS_SNAPHEAPLIST and/or TH32CS_SNAPMODULE.
  45. //
  46. // dwFlags
  47. //
  48. const
  49. {$EXTERNALSYM TH32CS_SNAPHEAPLIST}
  50.   TH32CS_SNAPHEAPLIST = $00000001;
  51. {$EXTERNALSYM TH32CS_SNAPPROCESS}
  52.   TH32CS_SNAPPROCESS  = $00000002;
  53. {$EXTERNALSYM TH32CS_SNAPTHREAD}
  54.   TH32CS_SNAPTHREAD   = $00000004;
  55. {$EXTERNALSYM TH32CS_SNAPMODULE}
  56.   TH32CS_SNAPMODULE   = $00000008;
  57. {$EXTERNALSYM TH32CS_SNAPALL}
  58.   TH32CS_SNAPALL      = TH32CS_SNAPHEAPLIST or TH32CS_SNAPPROCESS or
  59.     TH32CS_SNAPTHREAD or TH32CS_SNAPMODULE;
  60. {$EXTERNALSYM TH32CS_INHERIT}
  61.   TH32CS_INHERIT      = $80000000;
  62. //
  63. // Use CloseHandle to destroy the snapshot
  64. //
  65.  
  66. (****** heap walking ***************************************************)
  67.  
  68. type
  69. {$EXTERNALSYM tagHEAPLIST32}
  70.   tagHEAPLIST32 = record
  71.     dwSize: DWORD;
  72.     th32ProcessID: DWORD;  // owning process
  73.     th32HeapID: DWORD;     // heap (in owning process's context!)
  74.     dwFlags: DWORD;
  75.   end;
  76. {$EXTERNALSYM HEAPLIST32}
  77.   HEAPLIST32 = tagHEAPLIST32;
  78. {$EXTERNALSYM PHEAPLIST32}
  79.   PHEAPLIST32 = ^tagHEAPLIST32;
  80. {$EXTERNALSYM LPHEAPLIST32}
  81.   LPHEAPLIST32 = ^tagHEAPLIST32;
  82.   THeapList32 = tagHEAPLIST32;
  83. //
  84. // dwFlags
  85. //
  86. const
  87. {$EXTERNALSYM HF32_DEFAULT}
  88.   HF32_DEFAULT = 1;  // process's default heap
  89. {$EXTERNALSYM HF32_SHARED}
  90.   HF32_SHARED  = 2;  // is shared heap
  91.  
  92. {$EXTERNALSYM Heap32ListFirst}
  93. function Heap32ListFirst(hSnapshot: THandle; var lphl: THeapList32): BOOL;
  94. {$EXTERNALSYM Heap32ListNext}
  95. function Heap32ListNext(hSnapshot: THandle; var lphl: THeapList32): BOOL;
  96.  
  97. type
  98.   THeap32ListFirst = function (hSnapshot: THandle; var lphl: THeapList32): BOOL stdcall;
  99.   THeap32ListNext = function (hSnapshot: THandle; var lphl: THeapList32): BOOL stdcall;
  100.  
  101. type
  102. {$EXTERNALSYM tagHEAPENTRY32}
  103.   tagHEAPENTRY32 = record
  104.     dwSize: DWORD;
  105.     hHandle: THandle;     // Handle of this heap block
  106.     dwAddress: DWORD;     // Linear address of start of block
  107.     dwBlockSize: DWORD;   // Size of block in bytes
  108.     dwFlags: DWORD;
  109.     dwLockCount: DWORD;
  110.     dwResvd: DWORD;
  111.     th32ProcessID: DWORD; // owning process
  112.     th32HeapID: DWORD;    // heap block is in
  113.   end;
  114. {$EXTERNALSYM HEAPENTRY32}
  115.   HEAPENTRY32 = tagHEAPENTRY32;
  116. {$EXTERNALSYM PHEAPENTRY32}
  117.   PHEAPENTRY32 = ^tagHEAPENTRY32;
  118. {$EXTERNALSYM LPHEAPENTRY32}
  119.   LPHEAPENTRY32 = ^tagHEAPENTRY32;
  120.   THeapEntry32 = tagHEAPENTRY32;
  121. //
  122. // dwFlags
  123. //
  124. const
  125. {$EXTERNALSYM LF32_FIXED}
  126.   LF32_FIXED    = $00000001;
  127. {$EXTERNALSYM LF32_FREE}
  128.   LF32_FREE     = $00000002;
  129. {$EXTERNALSYM LF32_MOVEABLE}
  130.   LF32_MOVEABLE = $00000004;
  131.  
  132. {$EXTERNALSYM Heap32First}
  133. function Heap32First(var lphe: THeapEntry32; th32ProcessID, th32HeapID: DWORD): BOOL;
  134. {$EXTERNALSYM Heap32Next}
  135. function Heap32Next(var lphe: THeapEntry32): BOOL;
  136. {$EXTERNALSYM Toolhelp32ReadProcessMemory}
  137. function Toolhelp32ReadProcessMemory(th32ProcessID: DWORD; lpBaseAddress: Pointer;
  138.   var lpBuffer; cbRead: DWORD; var lpNumberOfBytesRead: DWORD): BOOL;
  139.  
  140. type
  141.   THeap32First = function (var lphe: THeapEntry32; th32ProcessID,
  142.     th32HeapID: DWORD): BOOL stdcall;
  143.   THeap32Next = function (var lphe: THeapEntry32): BOOL stdcall;
  144.   TToolhelp32ReadProcessMemory = function (th32ProcessID: DWORD;
  145.     lpBaseAddress: Pointer; var lpBuffer; cbRead: DWORD;
  146.     var lpNumberOfBytesRead: DWORD): BOOL stdcall;
  147.  
  148. (***** Process walking *************************************************)
  149.  
  150. type
  151. {$EXTERNALSYM tagPROCESSENTRY32W}
  152.   tagPROCESSENTRY32W = packed record
  153.     dwSize: DWORD;
  154.     cntUsage: DWORD;
  155.     th32ProcessID: DWORD;       // this process
  156.     th32DefaultHeapID: DWORD;
  157.     th32ModuleID: DWORD;        // associated exe
  158.     cntThreads: DWORD;
  159.     th32ParentProcessID: DWORD; // this process's parent process
  160.     pcPriClassBase: Longint;    // Base priority of process's threads
  161.     dwFlags: DWORD;
  162.     szExeFile: array[0..MAX_PATH - 1] of WChar;// Path
  163.   end;
  164. {$EXTERNALSYM PROCESSENTRY32W}
  165.   PROCESSENTRY32W = tagPROCESSENTRY32W;
  166. {$EXTERNALSYM PPROCESSENTRY32W}
  167.   PPROCESSENTRY32W = ^tagPROCESSENTRY32W;
  168. {$EXTERNALSYM LPPROCESSENTRY32W}
  169.   LPPROCESSENTRY32W = ^tagPROCESSENTRY32W;
  170.   TProcessEntry32W = tagPROCESSENTRY32W;
  171.  
  172. {$EXTERNALSYM Process32FirstW}
  173. function Process32FirstW(hSnapshot: THandle; var lppe: TProcessEntry32W): BOOL;
  174. {$EXTERNALSYM Process32NextW}
  175. function Process32NextW(hSnapshot: THandle; var lppe: TProcessEntry32W): BOOL;
  176.  
  177. type
  178.   TProcess32FirstW = function (hSnapshot: THandle; var lppe: TProcessEntry32W): BOOL stdcall;
  179.   TProcess32NextW = function (hSnapshot: THandle; var lppe: TProcessEntry32W): BOOL stdcall;
  180.  
  181. {$EXTERNALSYM tagPROCESSENTRY32}
  182.   tagPROCESSENTRY32 = packed record
  183.     dwSize: DWORD;
  184.     cntUsage: DWORD;
  185.     th32ProcessID: DWORD;       // this process
  186.     th32DefaultHeapID: DWORD;
  187.     th32ModuleID: DWORD;        // associated exe
  188.     cntThreads: DWORD;
  189.     th32ParentProcessID: DWORD; // this process's parent process
  190.     pcPriClassBase: Longint;    // Base priority of process's threads
  191.     dwFlags: DWORD;
  192.     szExeFile: array[0..MAX_PATH - 1] of Char;// Path
  193.   end;
  194. {$EXTERNALSYM PROCESSENTRY32}
  195.   PROCESSENTRY32 = tagPROCESSENTRY32;
  196. {$EXTERNALSYM PPROCESSENTRY32}
  197.   PPROCESSENTRY32 = ^tagPROCESSENTRY32;
  198. {$EXTERNALSYM LPPROCESSENTRY32}
  199.   LPPROCESSENTRY32 = ^tagPROCESSENTRY32;
  200.   TProcessEntry32 = tagPROCESSENTRY32;
  201.  
  202. {$EXTERNALSYM Process32First}
  203. function Process32First(hSnapshot: THandle; var lppe: TProcessEntry32): BOOL;
  204. {$EXTERNALSYM Process32Next}
  205. function Process32Next(hSnapshot: THandle; var lppe: TProcessEntry32): BOOL;
  206.  
  207. type
  208.   TProcess32First = function (hSnapshot: THandle; var lppe: TProcessEntry32): BOOL stdcall;
  209.   TProcess32Next = function (hSnapshot: THandle; var lppe: TProcessEntry32): BOOL stdcall;
  210.  
  211. (***** Thread walking **************************************************)
  212.  
  213. type
  214. {$EXTERNALSYM tagTHREADENTRY32}
  215.   tagTHREADENTRY32 = record
  216.     dwSize: DWORD;
  217.     cntUsage: DWORD;
  218.     th32ThreadID: DWORD;       // this thread
  219.     th32OwnerProcessID: DWORD; // Process this thread is associated with
  220.     tpBasePri: Longint;
  221.     tpDeltaPri: Longint;
  222.     dwFlags: DWORD;
  223.   end;
  224. {$EXTERNALSYM THREADENTRY32}
  225.   THREADENTRY32 = tagTHREADENTRY32;
  226. {$EXTERNALSYM PTHREADENTRY32}
  227.   PTHREADENTRY32 = ^tagTHREADENTRY32;
  228. {$EXTERNALSYM LPTHREADENTRY32}
  229.   LPTHREADENTRY32 = ^tagTHREADENTRY32;
  230.   TThreadEntry32 = tagTHREADENTRY32;
  231.  
  232. {$EXTERNALSYM Thread32First}
  233. function Thread32First(hSnapshot: THandle; var lpte: TThreadEntry32): BOOL; stdcall;
  234. {$EXTERNALSYM Thread32Next}
  235. function Thread32Next(hSnapshot: THandle; var lpte: TThreadENtry32): BOOL; stdcall;
  236.  
  237. type
  238.   TThread32First = function (hSnapshot: THandle; var lpte: TThreadEntry32): BOOL stdcall;
  239.   TThread32Next = function (hSnapshot: THandle; var lpte: TThreadENtry32): BOOL stdcall;
  240.  
  241. (***** Module walking *************************************************)
  242.  
  243. type
  244. {$EXTERNALSYM tagMODULEENTRY32}
  245.   tagMODULEENTRY32 = record
  246.     dwSize: DWORD;
  247.     th32ModuleID: DWORD;  // This module
  248.     th32ProcessID: DWORD; // owning process
  249.     GlblcntUsage: DWORD;  // Global usage count on the module
  250.     ProccntUsage: DWORD;  // Module usage count in th32ProcessID's context
  251.     modBaseAddr: PBYTE;   // Base address of module in th32ProcessID's context
  252.     modBaseSize: DWORD;   // Size in bytes of module starting at modBaseAddr
  253.     hModule: HMODULE;     // The hModule of this module in th32ProcessID's context
  254.     szModule: array[0..MAX_MODULE_NAME32] of Char;
  255.     szExePath: array[0..MAX_PATH - 1] of Char;
  256.   end;
  257. {$EXTERNALSYM MODULEENTRY32}
  258.   MODULEENTRY32 = tagMODULEENTRY32;
  259. {$EXTERNALSYM PMODULEENTRY32}
  260.   PMODULEENTRY32 = ^tagMODULEENTRY32;
  261. {$EXTERNALSYM LPMODULEENTRY32}
  262.   LPMODULEENTRY32 = ^tagMODULEENTRY32;
  263.   TModuleEntry32 = tagMODULEENTRY32;
  264.  
  265. //
  266. // NOTE CAREFULLY that the modBaseAddr and hModule fields are valid ONLY
  267. // in th32ProcessID's process context.
  268. //
  269.  
  270. {$EXTERNALSYM Module32First}
  271. function Module32First(hSnapshot: THandle; var lpme: TModuleEntry32): BOOL;
  272. {$EXTERNALSYM Module32Next}
  273. function Module32Next(hSnapshot: THandle; var lpme: TModuleEntry32): BOOL;
  274.  
  275. type
  276.   TModule32First = function (hSnapshot: THandle; var lpme: TModuleEntry32): BOOL stdcall;
  277.   TModule32Next = function (hSnapshot: THandle; var lpme: TModuleEntry32): BOOL stdcall;
  278.  
  279. {$EXTERNALSYM tagMODULEENTRY32W}
  280.   tagMODULEENTRY32W = record
  281.     dwSize: DWORD;
  282.     th32ModuleID: DWORD;  // This module
  283.     th32ProcessID: DWORD; // owning process
  284.     GlblcntUsage: DWORD;  // Global usage count on the module
  285.     ProccntUsage: DWORD;  // Module usage count in th32ProcessID's context
  286.     modBaseAddr: PBYTE;   // Base address of module in th32ProcessID's context
  287.     modBaseSize: DWORD;   // Size in bytes of module starting at modBaseAddr
  288.     hModule: HMODULE;     // The hModule of this module in th32ProcessID's context
  289.     szModule: array[0..MAX_MODULE_NAME32] of WChar;
  290.     szExePath: array[0..MAX_PATH - 1] of WChar;
  291.   end;
  292. {$EXTERNALSYM MODULEENTRY32}
  293.   MODULEENTRY32W = tagMODULEENTRY32W;
  294. {$EXTERNALSYM PMODULEENTRY32}
  295.   PMODULEENTRY32W = ^tagMODULEENTRY32W;
  296. {$EXTERNALSYM LPMODULEENTRY32}
  297.   LPMODULEENTRY32W = ^tagMODULEENTRY32W;
  298.   TModuleEntry32W = tagMODULEENTRY32W;
  299.  
  300. //
  301. // NOTE CAREFULLY that the modBaseAddr and hModule fields are valid ONLY
  302. // in th32ProcessID's process context.
  303. //
  304.  
  305. {$EXTERNALSYM Module32FirstW}
  306. function Module32FirstW(hSnapshot: THandle; var lpme: TModuleEntry32W): BOOL;
  307. {$EXTERNALSYM Module32NextW}
  308. function Module32NextW(hSnapshot: THandle; var lpme: TModuleEntry32W): BOOL;
  309.  
  310. type
  311.   TModule32FirstW = function (hSnapshot: THandle; var lpme: TModuleEntry32W): BOOL stdcall;
  312.   TModule32NextW = function (hSnapshot: THandle; var lpme: TModuleEntry32W): BOOL stdcall;
  313.  
  314. implementation
  315.  
  316. const
  317.   kernel32 = 'kernel32.dll';
  318.  
  319. var
  320.   KernelHandle: THandle;
  321.   _CreateToolhelp32Snapshot: TCreateToolhelp32Snapshot;
  322.   _Heap32ListFirst: THeap32ListFirst;
  323.   _Heap32ListNext: THeap32ListNext;
  324.   _Heap32First: THeap32First;
  325.   _Heap32Next: THeap32Next;
  326.   _Toolhelp32ReadProcessMemory: TToolhelp32ReadProcessMemory;
  327.   _Process32First: TProcess32First;
  328.   _Process32Next: TProcess32Next;
  329.   _Process32FirstW: TProcess32FirstW;
  330.   _Process32NextW: TProcess32NextW;
  331.   _Thread32First: TThread32First;
  332.   _Thread32Next: TThread32Next;
  333.   _Module32First: TModule32First;
  334.   _Module32Next: TModule32Next;
  335.   _Module32FirstW: TModule32FirstW;
  336.   _Module32NextW: TModule32NextW;
  337.  
  338. function InitToolHelp: Boolean;
  339. begin
  340.   if KernelHandle = 0 then
  341.   begin
  342.     KernelHandle := GetModuleHandle(kernel32);
  343.     if KernelHandle <> 0 then
  344.     begin
  345.       @_CreateToolhelp32Snapshot := GetProcAddress(KernelHandle, 'CreateToolhelp32Snapshot');
  346.       @_Heap32ListFirst := GetProcAddress(KernelHandle, 'Heap32ListFirst');
  347.       @_Heap32ListNext := GetProcAddress(KernelHandle, 'Heap32ListNext');
  348.       @_Heap32First := GetProcAddress(KernelHandle, 'Heap32First');
  349.       @_Heap32Next := GetProcAddress(KernelHandle, 'Heap32Next');
  350.       @_Toolhelp32ReadProcessMemory := GetProcAddress(KernelHandle, 'Toolhelp32ReadProcessMemory');
  351.       @_Process32First := GetProcAddress(KernelHandle, 'Process32First');
  352.       @_Process32Next := GetProcAddress(KernelHandle, 'Process32Next');
  353.       @_Process32FirstW := GetProcAddress(KernelHandle, 'Process32FirstW');
  354.       @_Process32NextW := GetProcAddress(KernelHandle, 'Process32NextW');
  355.       @_Thread32First := GetProcAddress(KernelHandle, 'Thread32First');
  356.       @_Thread32Next := GetProcAddress(KernelHandle, 'Thread32Next');
  357.       @_Module32First := GetProcAddress(KernelHandle, 'Module32First');
  358.       @_Module32Next := GetProcAddress(KernelHandle, 'Module32Next');
  359.       @_Module32FirstW := GetProcAddress(KernelHandle, 'Module32FirstW');
  360.       @_Module32NextW := GetProcAddress(KernelHandle, 'Module32NextW');
  361.     end;
  362.   end;
  363.   Result := (KernelHandle <> 0) and Assigned(_CreateToolhelp32Snapshot);
  364. end;
  365.  
  366. function CreateToolhelp32Snapshot;
  367. begin
  368.   if InitToolHelp then
  369.     Result := _CreateToolhelp32Snapshot(dwFlags, th32ProcessID)
  370.   else Result := 0;
  371. end;
  372.  
  373. function Heap32ListFirst;
  374. begin
  375.   if InitToolHelp then
  376.     Result := _Heap32ListFirst(hSnapshot, lphl)
  377.   else Result := False;
  378. end;
  379.  
  380. function Heap32ListNext;
  381. begin
  382.   if InitToolHelp then
  383.     Result := _Heap32ListNext(hSnapshot, lphl)
  384.   else Result := False;
  385. end;
  386.  
  387. function Heap32First;
  388. begin
  389.   if InitToolHelp then
  390.     Result := _Heap32First(lphe, th32ProcessID, th32HeapID)
  391.   else Result := False;
  392. end;
  393.  
  394. function Heap32Next;
  395. begin
  396.   if InitToolHelp then
  397.     Result := _Heap32Next(lphe)
  398.   else Result := False;
  399. end;
  400.  
  401. function Toolhelp32ReadProcessMemory;
  402. begin
  403.   if InitToolHelp then
  404.     Result := _Toolhelp32ReadProcessMemory(th32ProcessID, lpBaseAddress,
  405.       lpBuffer, cbRead, lpNumberOfBytesRead)
  406.   else Result := False;
  407. end;
  408.  
  409. function Process32First;
  410. begin
  411.   if InitToolHelp then
  412.     Result := _Process32First(hSnapshot, lppe)
  413.   else Result := False;
  414. end;
  415.  
  416. function Process32Next;
  417. begin
  418.   if InitToolHelp then
  419.     Result := _Process32Next(hSnapshot, lppe)
  420.   else Result := False;
  421. end;
  422.  
  423. function Process32FirstW;
  424. begin
  425.   if InitToolHelp then
  426.     Result := _Process32FirstW(hSnapshot, lppe)
  427.   else Result := False;
  428. end;
  429.  
  430. function Process32NextW;
  431. begin
  432.   if InitToolHelp then
  433.     Result := _Process32NextW(hSnapshot, lppe)
  434.   else Result := False;
  435. end;
  436.  
  437. function Thread32First;
  438. begin
  439.   if InitToolHelp then
  440.     Result := _Thread32First(hSnapshot, lpte)
  441.   else Result := False;
  442. end;
  443.  
  444. function Thread32Next;
  445. begin
  446.   if InitToolHelp then
  447.     Result := _Thread32Next(hSnapshot, lpte)
  448.   else Result := False;
  449. end;
  450.  
  451. function Module32First;
  452. begin
  453.   if InitToolHelp then
  454.     Result := _Module32First(hSnapshot, lpme)
  455.   else Result := False;
  456. end;
  457.  
  458. function Module32Next;
  459. begin
  460.   if InitToolHelp then
  461.     Result := _Module32Next(hSnapshot, lpme)
  462.   else Result := False;
  463. end;
  464.  
  465. function Module32FirstW;
  466. begin
  467.   if InitToolHelp then
  468.     Result := _Module32FirstW(hSnapshot, lpme)
  469.   else Result := False;
  470. end;
  471.  
  472. function Module32NextW;
  473. begin
  474.   if InitToolHelp then
  475.     Result := _Module32NextW(hSnapshot, lpme)
  476.   else Result := False;
  477. end;
  478.  
  479. end.
  480.  
  481.  
  482.